home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / Tickle-4.0 (tcl) / tcl / src / tclInt.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-03  |  35.2 KB  |  928 lines  |  [TEXT/MPS ]
  1. /*
  2.  * tclInt.h --
  3.  *
  4.  *    Declarations of things used internally by the Tcl interpreter.
  5.  *
  6.  * Copyright (c) 1987-1993 The Regents of the University of California.
  7.  * All rights reserved.
  8.  *
  9.  * Permission is hereby granted, without written agreement and without
  10.  * license or royalty fees, to use, copy, modify, and distribute this
  11.  * software and its documentation for any purpose, provided that the
  12.  * above copyright notice and the following two paragraphs appear in
  13.  * all copies of this software.
  14.  * 
  15.  * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
  16.  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
  17.  * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
  18.  * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  19.  *
  20.  * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  21.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  22.  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23.  * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
  24.  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  25.  *
  26.  * $Header: /user6/ouster/tcl/RCS/tclInt.h,v 1.89 93/09/09 16:11:06 ouster Exp $ SPRITE (Berkeley)
  27.  */
  28.  
  29. #ifndef _TCLINT
  30. #define _TCLINT
  31.  
  32. /*
  33.  * Common include files needed by most of the Tcl source files are
  34.  * included here, so that system-dependent personalizations for the
  35.  * include files only have to be made in once place.  This results
  36.  * in a few extra includes, but greater modularity.  The order of
  37.  * the three groups of #includes is important.  For example, stdio.h
  38.  * is needed by tcl.h, and the _ANSI_ARGS_ declaration in tcl.h is
  39.  * needed by stdlib.h in some configurations.
  40.  */
  41.  
  42. #include <stdio.h>
  43.  
  44. #ifndef _TCL
  45. #include "tcl.h"
  46. #endif
  47. #ifndef _REGEXP
  48. #include "tclRegexp.h"
  49. #endif
  50.  
  51. #include <ctype.h>
  52. #ifdef NO_LIMITS_H
  53. #   include "compat/limits.h"
  54. #else
  55. #   include <limits.h>
  56. #endif
  57. #ifdef NO_STDLIB_H
  58. #   include "compat/stdlib.h"
  59. #else
  60. #   include <stdlib.h>
  61. #endif
  62. #ifdef NO_STRING_H
  63. #include "compat/string.h"
  64. #else
  65. #include <string.h>
  66. #endif
  67. #ifdef macintosh
  68. #include <stdarg.h>
  69. #else
  70. #include <varargs.h>
  71. #endif
  72.  
  73. /*
  74.  * At present (12/91) not all stdlib.h implementations declare strtod.
  75.  * The declaration below is here to ensure that it's declared, so that
  76.  * the compiler won't take the default approach of assuming it returns
  77.  * an int.  There's no ANSI prototype for it because there would end
  78.  * up being too many conflicts with slightly-different prototypes.
  79.  */
  80.  
  81. extern double strtod();
  82.  
  83. /*
  84.  *----------------------------------------------------------------
  85.  * Data structures related to variables.   These are used primarily
  86.  * in tclVar.c
  87.  *----------------------------------------------------------------
  88.  */
  89.  
  90. /*
  91.  * The following structure defines a variable trace, which is used to
  92.  * invoke a specific C procedure whenever certain operations are performed
  93.  * on a variable.
  94.  */
  95.  
  96. typedef struct VarTrace {
  97.     Tcl_VarTraceProc *traceProc;/* Procedure to call when operations given
  98.                  * by flags are performed on variable. */
  99.     ClientData clientData;    /* Argument to pass to proc. */
  100.     int flags;            /* What events the trace procedure is
  101.                  * interested in:  OR-ed combination of
  102.                  * TCL_TRACE_READS, TCL_TRACE_WRITES, and
  103.                  * TCL_TRACE_UNSETS. */
  104.     struct VarTrace *nextPtr;    /* Next in list of traces associated with
  105.                  * a particular variable. */
  106. } VarTrace;
  107.  
  108. /*
  109.  * When a variable trace is active (i.e. its associated procedure is
  110.  * executing), one of the following structures is linked into a list
  111.  * associated with the variable's interpreter.  The information in
  112.  * the structure is needed in order for Tcl to behave reasonably
  113.  * if traces are deleted while traces are active.
  114.  */
  115.  
  116. typedef struct ActiveVarTrace {
  117.     struct Var *varPtr;        /* Variable that's being traced. */
  118.     struct ActiveVarTrace *nextPtr;
  119.                 /* Next in list of all active variable
  120.                  * traces for the interpreter, or NULL
  121.                  * if no more. */
  122.     VarTrace *nextTracePtr;    /* Next trace to check after current
  123.                  * trace procedure returns;  if this
  124.                  * trace gets deleted, must update pointer
  125.                  * to avoid using free'd memory. */
  126. } ActiveVarTrace;
  127.  
  128. /*
  129.  * The following structure describes an enumerative search in progress on
  130.  * an array variable;  this are invoked with options to the "array"
  131.  * command.
  132.  */
  133.  
  134. typedef struct ArraySearch {
  135.     int id;            /* Integer id used to distinguish among
  136.                  * multiple concurrent searches for the
  137.                  * same array. */
  138.     struct Var *varPtr;        /* Pointer to array variable that's being
  139.                  * searched. */
  140.     Tcl_HashSearch search;    /* Info kept by the hash module about
  141.                  * progress through the array. */
  142.     Tcl_HashEntry *nextEntry;    /* Non-null means this is the next element
  143.                  * to be enumerated (it's leftover from
  144.                  * the Tcl_FirstHashEntry call or from
  145.                  * an "array anymore" command).  NULL
  146.                  * means must call Tcl_NextHashEntry
  147.                  * to get value to return. */
  148.     struct ArraySearch *nextPtr;/* Next in list of all active searches
  149.                  * for this variable, or NULL if this is
  150.                  * the last one. */
  151. } ArraySearch;
  152.  
  153. /*
  154.  * The structure below defines a variable, which associates a string name
  155.  * with a string value.  Pointers to these structures are kept as the
  156.  * values of hash table entries, and the name of each variable is stored
  157.  * in the hash entry.
  158.  */
  159.  
  160. typedef struct Var {
  161.     int valueLength;        /* Holds the number of non-null bytes
  162.                  * actually occupied by the variable's
  163.                  * current value in value.string (extra
  164.                  * space is sometimes left for expansion).
  165.                  * For array and global variables this is
  166.                  * meaningless. */
  167.     int valueSpace;        /* Total number of bytes of space allocated
  168.                  * at value.string.  0 means there is no
  169.                  * space allocated. */
  170.     union {
  171.     char *string;        /* String value of variable, used for scalar
  172.                  * variables and array elements.  Malloc-ed. */
  173.     Tcl_HashTable *tablePtr;/* For array variables, this points to
  174.                  * information about the hash table used
  175.                  * to implement the associative array. 
  176.                  * Points to malloc-ed data. */
  177.     struct Var *upvarPtr;    /* If this is a global variable being
  178.                  * referred to in a procedure, or a variable
  179.                  * created by "upvar", this field points to
  180.                  * the record for the higher-level variable. */
  181.     } value;
  182.     Tcl_HashEntry *hPtr;    /* Hash table entry that refers to this
  183.                  * variable, or NULL if the variable has
  184.                  * been detached from its hash table (e.g.
  185.                  * an array is deleted, but some of its
  186.                  * elements are still referred to in upvars). */
  187.     int refCount;        /* Counts number of active uses of this
  188.                  * variable, not including its main hash
  189.                  * table entry: 1 for each additional variable
  190.                  * whose upVarPtr points here, 1 for each
  191.                  * nested trace active on variable.  This
  192.                  * record can't be deleted until refCount
  193.                  * becomes 0. */
  194.     VarTrace *tracePtr;        /* First in list of all traces set for this
  195.                  * variable. */
  196.     ArraySearch *searchPtr;    /* First in list of all searches active
  197.                  * for this variable, or NULL if none. */
  198.     int flags;            /* Miscellaneous bits of information about
  199.                  * variable.  See below for definitions. */
  200. } Var;
  201.  
  202. /*
  203.  * Flag bits for variables:
  204.  *
  205.  * VAR_ARRAY    -        1 means this is an array variable rather
  206.  *                than a scalar variable.
  207.  * VAR_UPVAR -             1 means this variable just contains a
  208.  *                pointer to another variable that has the
  209.  *                real value.  Variables like this come
  210.  *                about through the "upvar" and "global"
  211.  *                commands.
  212.  * VAR_UNDEFINED -        1 means that the variable is currently
  213.  *                undefined.  Undefined variables usually
  214.  *                go away completely, but if an undefined
  215.  *                variable has a trace on it, or if it is
  216.  *                a global variable being used by a procedure,
  217.  *                then it stays around even when undefined.
  218.  * VAR_TRACE_ACTIVE -        1 means that trace processing is currently
  219.  *                underway for a read or write access, so
  220.  *                new read or write accesses should not cause
  221.  *                trace procedures to be called and the
  222.  *                variable can't be deleted.
  223.  */
  224.  
  225. #define VAR_ARRAY        1
  226. #define VAR_UPVAR        2
  227. #define VAR_UNDEFINED        4
  228. #define VAR_TRACE_ACTIVE    0x10
  229.  
  230. /*
  231.  *----------------------------------------------------------------
  232.  * Data structures related to procedures.   These are used primarily
  233.  * in tclProc.c
  234.  *----------------------------------------------------------------
  235.  */
  236.  
  237. /*
  238.  * The structure below defines an argument to a procedure, which
  239.  * consists of a name and an (optional) default value.
  240.  */
  241.  
  242. typedef struct Arg {
  243.     struct Arg *nextPtr;    /* Next argument for this procedure,
  244.                  * or NULL if this is the last argument. */
  245.     char *defValue;        /* Pointer to arg's default value, or NULL
  246.                  * if no default value. */
  247.     char name[4];        /* Name of argument starts here.  The name
  248.                  * is followed by space for the default,
  249.                  * if there is one.  The actual size of this
  250.                  * field will be as large as necessary to
  251.                  * hold both name and default value.  THIS
  252.                  * MUST BE THE LAST FIELD IN THE STRUCTURE!! */
  253. } Arg;
  254.  
  255. /*
  256.  * The structure below defines a command procedure, which consists of
  257.  * a collection of Tcl commands plus information about arguments and
  258.  * variables.
  259.  */
  260.  
  261. typedef struct Proc {
  262.     struct Interp *iPtr;    /* Interpreter for which this command
  263.                  * is defined. */
  264.     int refCount;        /* Reference count:  1 if still present
  265.                  * in command table plus 1 for each call
  266.                  * to the procedure that is currently
  267.                  * active.  This structure can be freed
  268.                  * when refCount becomes zero. */
  269.     char *command;        /* Command that constitutes the body of
  270.                  * the procedure (dynamically allocated). */
  271.     Arg *argPtr;        /* Pointer to first of procedure's formal
  272.                  * arguments, or NULL if none. */
  273. } Proc;
  274.  
  275. /*
  276.  * The structure below defines a command trace.  This is used to allow Tcl
  277.  * clients to find out whenever a command is about to be executed.
  278.  */
  279.  
  280. typedef struct Trace {
  281.     int level;            /* Only trace commands at nesting level
  282.                  * less than or equal to this. */
  283.     Tcl_CmdTraceProc *proc;    /* Procedure to call to trace command. */
  284.     ClientData clientData;    /* Arbitrary value to pass to proc. */
  285.     struct Trace *nextPtr;    /* Next in list of traces for this interp. */
  286. } Trace;
  287.  
  288. /*
  289.  * The stucture below defines a deletion callback, which is
  290.  * a procedure to invoke just before an interpreter is deleted.
  291.  */
  292.  
  293. typedef struct DeleteCallback {
  294.     Tcl_InterpDeleteProc *proc;    /* Procedure to call. */
  295.     ClientData clientData;    /* Value to pass to procedure. */
  296.     struct DeleteCallback *nextPtr;
  297.                 /* Next in list of callbacks for this
  298.                  * interpreter (or NULL for end of list). */
  299. } DeleteCallback;
  300.  
  301. /*
  302.  * The structure below defines a frame, which is a procedure invocation.
  303.  * These structures exist only while procedures are being executed, and
  304.  * provide a sort of call stack.
  305.  */
  306.  
  307. typedef struct CallFrame {
  308.     Tcl_HashTable varTable;    /* Hash table containing all of procedure's
  309.                  * local variables. */
  310.     int level;            /* Level of this procedure, for "uplevel"
  311.                  * purposes (i.e. corresponds to nesting of
  312.                  * callerVarPtr's, not callerPtr's).  1 means
  313.                  * outer-most procedure, 0 means top-level. */
  314.     int argc;            /* This and argv below describe name and
  315.                  * arguments for this procedure invocation. */
  316.     char **argv;        /* Array of arguments. */
  317.     struct CallFrame *callerPtr;
  318.                 /* Value of interp->framePtr when this
  319.                  * procedure was invoked (i.e. next in
  320.                  * stack of all active procedures). */
  321.     struct CallFrame *callerVarPtr;
  322.                 /* Value of interp->varFramePtr when this
  323.                  * procedure was invoked (i.e. determines
  324.                  * variable scoping within caller;  same
  325.                  * as callerPtr unless an "uplevel" command
  326.                  * or something equivalent was active in
  327.                  * the caller). */
  328. } CallFrame;
  329.  
  330. /*
  331.  * The structure below defines one history event (a previously-executed
  332.  * command that can be re-executed in whole or in part).
  333.  */
  334.  
  335. typedef struct {
  336.     char *command;        /* String containing previously-executed
  337.                  * command. */
  338.     int bytesAvl;        /* Total # of bytes available at *event (not
  339.                  * all are necessarily in use now). */
  340. } HistoryEvent;
  341.  
  342. /*
  343.  *----------------------------------------------------------------
  344.  * Data structures related to history.   These are used primarily
  345.  * in tclHistory.c
  346.  *----------------------------------------------------------------
  347.  */
  348.  
  349. /*
  350.  * The structure below defines a pending revision to the most recent
  351.  * history event.  Changes are linked together into a list and applied
  352.  * during the next call to Tcl_RecordHistory.  See the comments at the
  353.  * beginning of tclHistory.c for information on revisions.
  354.  */
  355.  
  356. typedef struct HistoryRev {
  357.     int firstIndex;        /* Index of the first byte to replace in
  358.                  * current history event. */
  359.     int lastIndex;        /* Index of last byte to replace in
  360.                  * current history event. */
  361.     int newSize;        /* Number of bytes in newBytes. */
  362.     char *newBytes;        /* Replacement for the range given by
  363.                  * firstIndex and lastIndex. */
  364.     struct HistoryRev *nextPtr;    /* Next in chain of revisions to apply, or
  365.                  * NULL for end of list. */
  366. } HistoryRev;
  367.  
  368. /*
  369.  *----------------------------------------------------------------
  370.  * Data structures related to files.  These are used primarily in
  371.  * tclUnixUtil.c and tclUnixAZ.c.
  372.  *----------------------------------------------------------------
  373.  */
  374.  
  375. /*
  376.  * The data structure below defines an open file (or connection to
  377.  * a process pipeline) as returned by the "open" command.
  378.  */
  379.  
  380. typedef struct OpenFile {
  381.     FILE *f;            /* Stdio file to use for reading and/or
  382.                  * writing. */
  383.     FILE *f2;            /* Normally NULL.  In the special case of
  384.                  * a command pipeline with pipes for both
  385.                  * input and output, this is a stdio file
  386.                  * to use for writing to the pipeline. */
  387.     int permissions;        /* OR-ed combination of TCL_FILE_READABLE
  388.                  * and TCL_FILE_WRITABLE. */
  389.     int numPids;        /* If this is a connection to a process
  390.                  * pipeline, gives number of processes
  391.                  * in pidPtr array below;  otherwise it
  392.                  * is 0. */
  393.     int *pidPtr;        /* Pointer to malloc-ed array of child
  394.                  * process ids (numPids of them), or NULL
  395.                  * if this isn't a connection to a process
  396.                  * pipeline. */
  397.     int errorId;        /* File id of file that receives error
  398.                  * output from pipeline.  -1 means not
  399.                  * used (i.e. this is a normal file). */
  400. } OpenFile;
  401.  
  402. /*
  403.  *----------------------------------------------------------------
  404.  * Data structures related to expressions.  These are used only in
  405.  * tclExpr.c.
  406.  *----------------------------------------------------------------
  407.  */
  408.  
  409. /*
  410.  * The data structure below defines a math function (e.g. sin or hypot)
  411.  * for use in Tcl expressions.
  412.  */
  413.  
  414. #define MAX_MATH_ARGS 5
  415. typedef struct MathFunc {
  416.     int numArgs;        /* Number of arguments for function. */
  417.     Tcl_ValueType argTypes[MAX_MATH_ARGS];
  418.                 /* Acceptable types for each argument. */
  419.     Tcl_MathProc *proc;        /* Procedure that implements this function. */
  420.     ClientData clientData;    /* Additional argument to pass to the function
  421.                  * when invoking it. */
  422. } MathFunc;
  423.  
  424. /*
  425.  *----------------------------------------------------------------
  426.  * This structure defines an interpreter, which is a collection of
  427.  * commands plus other state information related to interpreting
  428.  * commands, such as variable storage.  Primary responsibility for
  429.  * this data structure is in tclBasic.c, but almost every Tcl
  430.  * source file uses something in here.
  431.  *----------------------------------------------------------------
  432.  */
  433.  
  434. typedef struct Command {
  435.     Tcl_CmdProc *proc;        /* Procedure to process command. */
  436.     ClientData clientData;    /* Arbitrary value to pass to proc. */
  437.     Tcl_CmdDeleteProc *deleteProc;
  438.                 /* Procedure to invoke when deleting
  439.                  * command. */
  440.     ClientData deleteData;    /* Arbitrary value to pass to deleteProc
  441.                  * (usually the same as clientData). */
  442. } Command;
  443.  
  444. #define CMD_SIZE(nameLength) ((unsigned) sizeof(Command) + nameLength - 3)
  445.  
  446. typedef struct Interp {
  447.  
  448.     /*
  449.      * Note:  the first three fields must match exactly the fields in
  450.      * a Tcl_Interp struct (see tcl.h).  If you change one, be sure to
  451.      * change the other.
  452.      */
  453.  
  454.     char *result;        /* Points to result returned by last
  455.                  * command. */
  456.     Tcl_FreeProc *freeProc;    /* Zero means result is statically allocated.
  457.                  * If non-zero, gives address of procedure
  458.                  * to invoke to free the result.  Must be
  459.                  * freed by Tcl_Eval before executing next
  460.                  * command. */
  461.     int errorLine;        /* When TCL_ERROR is returned, this gives
  462.                  * the line number within the command where
  463.                  * the error occurred (1 means first line). */
  464.     Tcl_HashTable commandTable;    /* Contains all of the commands currently
  465.                  * registered in this interpreter.  Indexed
  466.                  * by strings; values have type (Command *). */
  467.     Tcl_HashTable mathFuncTable;/* Contains all of the math functions currently
  468.                  * defined for the interpreter.  Indexed by
  469.                  * strings (function names);  values have
  470.                  * type (MathFunc *). */
  471.  
  472.     /*
  473.      * Information related to procedures and variables.  See tclProc.c
  474.      * and tclvar.c for usage.
  475.      */
  476.  
  477.     Tcl_HashTable globalTable;    /* Contains all global variables for
  478.                  * interpreter. */
  479.     int numLevels;        /* Keeps track of how many nested calls to
  480.                  * Tcl_Eval are in progress for this
  481.                  * interpreter.  It's used to delay deletion
  482.                  * of the table until all Tcl_Eval invocations
  483.                  * are completed. */
  484.     int maxNestingDepth;    /* If numLevels exceeds this value then Tcl
  485.                  * assumes that infinite recursion has
  486.                  * occurred and it generates an error. */
  487.     CallFrame *framePtr;    /* Points to top-most in stack of all nested
  488.                  * procedure invocations.  NULL means there
  489.                  * are no active procedures. */
  490.     CallFrame *varFramePtr;    /* Points to the call frame whose variables
  491.                  * are currently in use (same as framePtr
  492.                  * unless an "uplevel" command is being
  493.                  * executed).  NULL means no procedure is
  494.                  * active or "uplevel 0" is being exec'ed. */
  495.     ActiveVarTrace *activeTracePtr;
  496.                 /* First in list of active traces for interp,
  497.                  * or NULL if no active traces. */
  498.     int returnCode;        /* Completion code to return if current
  499.                  * procedure exits with a TCL_RETURN code. */
  500.     char *errorInfo;        /* Value to store in errorInfo if returnCode
  501.                  * is TCL_ERROR.  Malloc'ed, may be NULL */
  502.     char *errorCode;        /* Value to store in errorCode if returnCode
  503.                  * is TCL_ERROR.  Malloc'ed, may be NULL */
  504.  
  505.     /*
  506.      * Information related to history:
  507.      */
  508.  
  509.     int numEvents;        /* Number of previously-executed commands
  510.                  * to retain. */
  511.     HistoryEvent *events;    /* Array containing numEvents entries
  512.                  * (dynamically allocated). */
  513.     int curEvent;        /* Index into events of place where current
  514.                  * (or most recent) command is recorded. */
  515.     int curEventNum;        /* Event number associated with the slot
  516.                  * given by curEvent. */
  517.     HistoryRev *revPtr;        /* First in list of pending revisions. */
  518.     char *historyFirst;        /* First char. of current command executed
  519.                  * from history module or NULL if none. */
  520.     int revDisables;        /* 0 means history revision OK;  > 0 gives
  521.                  * a count of number of times revision has
  522.                  * been disabled. */
  523.     char *evalFirst;        /* If TCL_RECORD_BOUNDS flag set, Tcl_Eval
  524.                  * sets this field to point to the first
  525.                  * char. of text from which the current
  526.                  * command came.  Otherwise Tcl_Eval sets
  527.                  * this to NULL. */
  528.     char *evalLast;        /* Similar to evalFirst, except points to
  529.                  * last character of current command. */
  530.  
  531.     /*
  532.      * Information used by Tcl_AppendResult to keep track of partial
  533.      * results.  See Tcl_AppendResult code for details.
  534.      */
  535.  
  536.     char *appendResult;        /* Storage space for results generated
  537.                  * by Tcl_AppendResult.  Malloc-ed.  NULL
  538.                  * means not yet allocated. */
  539.     int appendAvl;        /* Total amount of space available at
  540.                  * partialResult. */
  541.     int appendUsed;        /* Number of non-null bytes currently
  542.                  * stored at partialResult. */
  543.  
  544.     /*
  545.      * A cache of compiled regular expressions.  See TclCompileRegexp
  546.      * in tclUtil.c for details.
  547.      */
  548.  
  549. #define NUM_REGEXPS 5
  550.     char *patterns[NUM_REGEXPS];/* Strings corresponding to compiled
  551.                  * regular expression patterns.  NULL
  552.                  * means that this slot isn't used.
  553.                  * Malloc-ed. */
  554.     int patLengths[NUM_REGEXPS];/* Number of non-null characters in
  555.                  * corresponding entry in patterns.
  556.                  * -1 means entry isn't used. */
  557.     regexp *regexps[NUM_REGEXPS];
  558.                 /* Compiled forms of above strings.  Also
  559.                  * malloc-ed, or NULL if not in use yet. */
  560.  
  561.     /*
  562.      * Information used by Tcl_PrintDouble:
  563.      */
  564.  
  565.     char pdFormat[10];        /* Format string used by Tcl_PrintDouble. */
  566.     int pdPrec;            /* Current precision (used to restore the
  567.                  * the tcl_precision variable after a bogus
  568.                  * value has been put into it). */
  569.  
  570.     /*
  571.      * Miscellaneous information:
  572.      */
  573.  
  574.     int cmdCount;        /* Total number of times a command procedure
  575.                  * has been called for this interpreter. */
  576.     int noEval;            /* Non-zero means no commands should actually
  577.                  * be executed:  just parse only.  Used in
  578.                  * expressions when the result is already
  579.                  * determined. */
  580.     int evalFlags;        /* Flags to control next call to Tcl_Eval.
  581.                  * Normally zero, but may be set before
  582.                  * calling Tcl_Eval to an OR'ed combination
  583.                  * of TCL_BRACKET_TERM and TCL_RECORD_BOUNDS. */
  584.     char *termPtr;        /* Character just after the last one in
  585.                  * a command.  Set by Tcl_Eval before
  586.                  * returning. */
  587.     char *scriptFile;        /* NULL means there is no nested source
  588.                  * command active;  otherwise this points to
  589.                  * the name of the file being sourced (it's
  590.                  * not malloc-ed:  it points to an argument
  591.                  * to Tcl_EvalFile. */
  592.     int flags;            /* Various flag bits.  See below. */
  593.     Trace *tracePtr;        /* List of traces for this interpreter. */
  594.     DeleteCallback *deleteCallbackPtr;
  595.                 /* First in list of callbacks to invoke when
  596.                  * interpeter is deleted. */
  597.     char resultSpace[TCL_RESULT_SIZE+1];
  598.                 /* Static space for storing small results. */
  599. } Interp;
  600.  
  601. /*
  602.  * Flag bits for Interp structures:
  603.  *
  604.  * DELETED:        Non-zero means the interpreter has been deleted:
  605.  *            don't process any more commands for it, and destroy
  606.  *            the structure as soon as all nested invocations of
  607.  *            Tcl_Eval are done.
  608.  * ERR_IN_PROGRESS:    Non-zero means an error unwind is already in progress.
  609.  *            Zero means a command proc has been invoked since last
  610.  *            error occured.
  611.  * ERR_ALREADY_LOGGED:    Non-zero means information has already been logged
  612.  *            in $errorInfo for the current Tcl_Eval instance,
  613.  *            so Tcl_Eval needn't log it (used to implement the
  614.  *            "error message log" command).
  615.  * ERROR_CODE_SET:    Non-zero means that Tcl_SetErrorCode has been
  616.  *            called to record information for the current
  617.  *            error.  Zero means Tcl_Eval must clear the
  618.  *            errorCode variable if an error is returned.
  619.  * EXPR_INITIALIZED:    1 means initialization specific to expressions has
  620.  *            been carried out.
  621.  */
  622.  
  623. #define DELETED            1
  624. #define ERR_IN_PROGRESS        2
  625. #define ERR_ALREADY_LOGGED    4
  626. #define ERROR_CODE_SET        8
  627. #define EXPR_INITIALIZED    0x10
  628.  
  629. /*
  630.  * Default value for the pdPrec and pdFormat fields of interpreters:
  631.  */
  632.  
  633. #define DEFAULT_PD_PREC 6
  634. #define DEFAULT_PD_FORMAT "%g"
  635.  
  636. /*
  637.  *----------------------------------------------------------------
  638.  * Data structures related to command parsing.   These are used in
  639.  * tclParse.c and its clients.
  640.  *----------------------------------------------------------------
  641.  */
  642.  
  643. /*
  644.  * The following data structure is used by various parsing procedures
  645.  * to hold information about where to store the results of parsing
  646.  * (e.g. the substituted contents of a quoted argument, or the result
  647.  * of a nested command).  At any given time, the space available
  648.  * for output is fixed, but a procedure may be called to expand the
  649.  * space available if the current space runs out.
  650.  */
  651.  
  652. typedef struct ParseValue {
  653.     char *buffer;        /* Address of first character in
  654.                  * output buffer. */
  655.     char *next;            /* Place to store next character in
  656.                  * output buffer. */
  657.     char *end;            /* Address of the last usable character
  658.                  * in the buffer. */
  659.     void (*expandProc) _ANSI_ARGS_((struct ParseValue *pvPtr, int needed));
  660.                 /* Procedure to call when space runs out;
  661.                  * it will make more space. */
  662.     ClientData clientData;    /* Arbitrary information for use of
  663.                  * expandProc. */
  664. } ParseValue;
  665.  
  666. /*
  667.  * A table used to classify input characters to assist in parsing
  668.  * Tcl commands.  The table should be indexed with a signed character
  669.  * using the CHAR_TYPE macro.  The character may have a negative
  670.  * value.
  671.  */
  672.  
  673. extern char tclTypeTable[];
  674. #define CHAR_TYPE(c) (tclTypeTable+128)[c]
  675.  
  676. /*
  677.  * Possible values returned by CHAR_TYPE:
  678.  *
  679.  * TCL_NORMAL -        All characters that don't have special significance
  680.  *            to the Tcl language.
  681.  * TCL_SPACE -        Character is space, tab, or return.
  682.  * TCL_COMMAND_END -    Character is newline or null or semicolon or
  683.  *            close-bracket.
  684.  * TCL_QUOTE -        Character is a double-quote.
  685.  * TCL_OPEN_BRACKET -    Character is a "[".
  686.  * TCL_OPEN_BRACE -    Character is a "{".
  687.  * TCL_CLOSE_BRACE -    Character is a "}".
  688.  * TCL_BACKSLASH -    Character is a "\".
  689.  * TCL_DOLLAR -        Character is a "$".
  690.  */
  691.  
  692. #define TCL_NORMAL        0
  693. #define TCL_SPACE        1
  694. #define TCL_COMMAND_END        2
  695. #define TCL_QUOTE        3
  696. #define TCL_OPEN_BRACKET    4
  697. #define TCL_OPEN_BRACE        5
  698. #define TCL_CLOSE_BRACE        6
  699. #define TCL_BACKSLASH        7
  700. #define TCL_DOLLAR        8
  701.  
  702. /*
  703.  * Additional flags passed to Tcl_Eval.  See tcl.h for other flags to
  704.  * Tcl_Eval;  these ones are only used internally by Tcl.
  705.  *
  706.  * TCL_RECORD_BOUNDS    Tells Tcl_Eval to record information in the
  707.  *            evalFirst and evalLast fields for each command
  708.  *            executed directly from the string (top-level
  709.  *            commands and those from command substitution).
  710.  */
  711.  
  712. #define TCL_RECORD_BOUNDS    0x100
  713.  
  714. /*
  715.  * Maximum number of levels of nesting permitted in Tcl commands (used
  716.  * to catch infinite recursion).
  717.  */
  718.  
  719. #define MAX_NESTING_DEPTH    1000
  720.  
  721. /*
  722.  * The macro below is used to modify a "char" value (e.g. by casting
  723.  * it to an unsigned character) so that it can be used safely with
  724.  * macros such as isspace.
  725.  */
  726.  
  727. #define UCHAR(c) ((unsigned char) (c))
  728.  
  729. /*
  730.  * Variables shared among Tcl modules but not used by the outside
  731.  * world:
  732.  */
  733.  
  734. extern int        tclNumFiles;
  735. extern OpenFile **    tclOpenFiles;
  736. extern char *        tclRegexpError;
  737.  
  738. /*
  739.  *----------------------------------------------------------------
  740.  * Procedures shared among Tcl modules but not used by the outside
  741.  * world:
  742.  *----------------------------------------------------------------
  743.  */
  744.  
  745. extern void        panic();
  746. extern regexp *        TclCompileRegexp _ANSI_ARGS_((Tcl_Interp *interp,
  747.                 char *string));
  748. extern void        TclCopyAndCollapse _ANSI_ARGS_((int count, char *src,
  749.                 char *dst));
  750. extern void        TclDeleteVars _ANSI_ARGS_((Interp *iPtr,
  751.                 Tcl_HashTable *tablePtr));
  752. extern void        TclExpandParseValue _ANSI_ARGS_((ParseValue *pvPtr,
  753.                 int needed));
  754. extern int        TclFindElement _ANSI_ARGS_((Tcl_Interp *interp,
  755.                 char *list, char **elementPtr, char **nextPtr,
  756.                 int *sizePtr, int *bracePtr));
  757. extern Proc *        TclFindProc _ANSI_ARGS_((Interp *iPtr,
  758.                 char *procName));
  759. extern int        TclGetFrame _ANSI_ARGS_((Tcl_Interp *interp,
  760.                 char *string, CallFrame **framePtrPtr));
  761. extern int        TclGetListIndex _ANSI_ARGS_((Tcl_Interp *interp,
  762.                 char *string, int *indexPtr));
  763. extern Proc *        TclIsProc _ANSI_ARGS_((Command *cmdPtr));
  764. extern int        TclParseBraces _ANSI_ARGS_((Tcl_Interp *interp,
  765.                 char *string, char **termPtr, ParseValue *pvPtr));
  766. extern int        TclParseNestedCmd _ANSI_ARGS_((Tcl_Interp *interp,
  767.                 char *string, int flags, char **termPtr,
  768.                 ParseValue *pvPtr));
  769. extern int        TclParseQuotes _ANSI_ARGS_((Tcl_Interp *interp,
  770.                 char *string, int termChar, int flags,
  771.                 char **termPtr, ParseValue *pvPtr));
  772. extern int        TclParseWords _ANSI_ARGS_((Tcl_Interp *interp,
  773.                 char *string, int flags, int maxWords,
  774.                 char **termPtr, int *argcPtr, char **argv,
  775.                 ParseValue *pvPtr));
  776. extern char *        TclPrecTraceProc _ANSI_ARGS_((ClientData clientData,
  777.                 Tcl_Interp *interp, char *name1, char *name2,
  778.                 int flags));
  779. extern void        TclSetupEnv _ANSI_ARGS_((Tcl_Interp *interp));
  780. extern char *        TclWordEnd _ANSI_ARGS_((char *start, int nested));
  781.  
  782. /*
  783.  *----------------------------------------------------------------
  784.  * Command procedures in the generic core:
  785.  *----------------------------------------------------------------
  786.  */
  787.  
  788. extern int    Tcl_AppendCmd _ANSI_ARGS_((ClientData clientData,
  789.             Tcl_Interp *interp, int argc, char **argv));
  790. extern int    Tcl_ArrayCmd _ANSI_ARGS_((ClientData clientData,
  791.             Tcl_Interp *interp, int argc, char **argv));
  792. extern int    Tcl_BreakCmd _ANSI_ARGS_((ClientData clientData,
  793.             Tcl_Interp *interp, int argc, char **argv));
  794. extern int    Tcl_CaseCmd _ANSI_ARGS_((ClientData clientData,
  795.             Tcl_Interp *interp, int argc, char **argv));
  796. extern int    Tcl_CatchCmd _ANSI_ARGS_((ClientData clientData,
  797.             Tcl_Interp *interp, int argc, char **argv));
  798. extern int    Tcl_ConcatCmd _ANSI_ARGS_((ClientData clientData,
  799.             Tcl_Interp *interp, int argc, char **argv));
  800. extern int    Tcl_ContinueCmd _ANSI_ARGS_((ClientData clientData,
  801.             Tcl_Interp *interp, int argc, char **argv));
  802. extern int    Tcl_ErrorCmd _ANSI_ARGS_((ClientData clientData,
  803.             Tcl_Interp *interp, int argc, char **argv));
  804. extern int    Tcl_EvalCmd _ANSI_ARGS_((ClientData clientData,
  805.             Tcl_Interp *interp, int argc, char **argv));
  806. extern int    Tcl_ExprCmd _ANSI_ARGS_((ClientData clientData,
  807.             Tcl_Interp *interp, int argc, char **argv));
  808. extern int    Tcl_ForCmd _ANSI_ARGS_((ClientData clientData,
  809.             Tcl_Interp *interp, int argc, char **argv));
  810. extern int    Tcl_ForeachCmd _ANSI_ARGS_((ClientData clientData,
  811.             Tcl_Interp *interp, int argc, char **argv));
  812. extern int    Tcl_FormatCmd _ANSI_ARGS_((ClientData clientData,
  813.             Tcl_Interp *interp, int argc, char **argv));
  814. extern int    Tcl_GlobalCmd _ANSI_ARGS_((ClientData clientData,
  815.             Tcl_Interp *interp, int argc, char **argv));
  816. extern int    Tcl_HistoryCmd _ANSI_ARGS_((ClientData clientData,
  817.             Tcl_Interp *interp, int argc, char **argv));
  818. extern int    Tcl_IfCmd _ANSI_ARGS_((ClientData clientData,
  819.             Tcl_Interp *interp, int argc, char **argv));
  820. extern int    Tcl_IncrCmd _ANSI_ARGS_((ClientData clientData,
  821.             Tcl_Interp *interp, int argc, char **argv));
  822. extern int    Tcl_InfoCmd _ANSI_ARGS_((ClientData clientData,
  823.             Tcl_Interp *interp, int argc, char **argv));
  824. extern int    Tcl_JoinCmd _ANSI_ARGS_((ClientData clientData,
  825.             Tcl_Interp *interp, int argc, char **argv));
  826. extern int    Tcl_LappendCmd _ANSI_ARGS_((ClientData clientData,
  827.             Tcl_Interp *interp, int argc, char **argv));
  828. extern int    Tcl_LindexCmd _ANSI_ARGS_((ClientData clientData,
  829.             Tcl_Interp *interp, int argc, char **argv));
  830. extern int    Tcl_LinsertCmd _ANSI_ARGS_((ClientData clientData,
  831.             Tcl_Interp *interp, int argc, char **argv));
  832. extern int    Tcl_LlengthCmd _ANSI_ARGS_((ClientData clientData,
  833.             Tcl_Interp *interp, int argc, char **argv));
  834. extern int    Tcl_ListCmd _ANSI_ARGS_((ClientData clientData,
  835.             Tcl_Interp *interp, int argc, char **argv));
  836. extern int    Tcl_LrangeCmd _ANSI_ARGS_((ClientData clientData,
  837.             Tcl_Interp *interp, int argc, char **argv));
  838. extern int    Tcl_LreplaceCmd _ANSI_ARGS_((ClientData clientData,
  839.             Tcl_Interp *interp, int argc, char **argv));
  840. extern int    Tcl_LsearchCmd _ANSI_ARGS_((ClientData clientData,
  841.             Tcl_Interp *interp, int argc, char **argv));
  842. extern int    Tcl_LsortCmd _ANSI_ARGS_((ClientData clientData,
  843.             Tcl_Interp *interp, int argc, char **argv));
  844. extern int    Tcl_ProcCmd _ANSI_ARGS_((ClientData clientData,
  845.             Tcl_Interp *interp, int argc, char **argv));
  846. extern int    Tcl_RegexpCmd _ANSI_ARGS_((ClientData clientData,
  847.             Tcl_Interp *interp, int argc, char **argv));
  848. extern int    Tcl_RegsubCmd _ANSI_ARGS_((ClientData clientData,
  849.             Tcl_Interp *interp, int argc, char **argv));
  850. extern int    Tcl_RenameCmd _ANSI_ARGS_((ClientData clientData,
  851.             Tcl_Interp *interp, int argc, char **argv));
  852. extern int    Tcl_ReturnCmd _ANSI_ARGS_((ClientData clientData,
  853.             Tcl_Interp *interp, int argc, char **argv));
  854. extern int    Tcl_ScanCmd _ANSI_ARGS_((ClientData clientData,
  855.             Tcl_Interp *interp, int argc, char **argv));
  856. extern int    Tcl_SetCmd _ANSI_ARGS_((ClientData clientData,
  857.             Tcl_Interp *interp, int argc, char **argv));
  858. extern int    Tcl_SplitCmd _ANSI_ARGS_((ClientData clientData,
  859.             Tcl_Interp *interp, int argc, char **argv));
  860. extern int    Tcl_StringCmd _ANSI_ARGS_((ClientData clientData,
  861.             Tcl_Interp *interp, int argc, char **argv));
  862. extern int    Tcl_SwitchCmd _ANSI_ARGS_((ClientData clientData,
  863.             Tcl_Interp *interp, int argc, char **argv));
  864. extern int    Tcl_TraceCmd _ANSI_ARGS_((ClientData clientData,
  865.             Tcl_Interp *interp, int argc, char **argv));
  866. extern int    Tcl_UnsetCmd _ANSI_ARGS_((ClientData clientData,
  867.             Tcl_Interp *interp, int argc, char **argv));
  868. extern int    Tcl_UplevelCmd _ANSI_ARGS_((ClientData clientData,
  869.             Tcl_Interp *interp, int argc, char **argv));
  870. extern int    Tcl_UpvarCmd _ANSI_ARGS_((ClientData clientData,
  871.             Tcl_Interp *interp, int argc, char **argv));
  872. extern int    Tcl_WhileCmd _ANSI_ARGS_((ClientData clientData,
  873.             Tcl_Interp *interp, int argc, char **argv));
  874. extern int    Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
  875.             Tcl_Interp *interp, int argc, char **argv));
  876. extern int    Tcl_Cmd _ANSI_ARGS_((ClientData clientData,
  877.             Tcl_Interp *interp, int argc, char **argv));
  878.  
  879. /*
  880.  *----------------------------------------------------------------
  881.  * Command procedures in the UNIX core:
  882.  *----------------------------------------------------------------
  883.  */
  884.  
  885. extern int    Tcl_CdCmd _ANSI_ARGS_((ClientData clientData,
  886.             Tcl_Interp *interp, int argc, char **argv));
  887. extern int    Tcl_CloseCmd _ANSI_ARGS_((ClientData clientData,
  888.             Tcl_Interp *interp, int argc, char **argv));
  889. extern int    Tcl_EofCmd _ANSI_ARGS_((ClientData clientData,
  890.             Tcl_Interp *interp, int argc, char **argv));
  891. extern int    Tcl_ExecCmd _ANSI_ARGS_((ClientData clientData,
  892.             Tcl_Interp *interp, int argc, char **argv));
  893. extern int    Tcl_ExitCmd _ANSI_ARGS_((ClientData clientData,
  894.             Tcl_Interp *interp, int argc, char **argv));
  895. extern int    Tcl_FileCmd _ANSI_ARGS_((ClientData clientData,
  896.             Tcl_Interp *interp, int argc, char **argv));
  897. extern int    Tcl_FlushCmd _ANSI_ARGS_((ClientData clientData,
  898.             Tcl_Interp *interp, int argc, char **argv));
  899. extern int    Tcl_GetsCmd _ANSI_ARGS_((ClientData clientData,
  900.             Tcl_Interp *interp, int argc, char **argv));
  901. extern int    Tcl_GlobCmd _ANSI_ARGS_((ClientData clientData,
  902.             Tcl_Interp *interp, int argc, char **argv));
  903. extern int    Tcl_OpenCmd _ANSI_ARGS_((ClientData clientData,
  904.             Tcl_Interp *interp, int argc, char **argv));
  905. extern int    Tcl_PutsCmd _ANSI_ARGS_((ClientData clientData,
  906.             Tcl_Interp *interp, int argc, char **argv));
  907. extern int    Tcl_PidCmd _ANSI_ARGS_((ClientData clientData,
  908.             Tcl_Interp *interp, int argc, char **argv));
  909. extern int    Tcl_PwdCmd _ANSI_ARGS_((ClientData clientData,
  910.             Tcl_Interp *interp, int argc, char **argv));
  911. extern int    Tcl_ReadCmd _ANSI_ARGS_((ClientData clientData,
  912.             Tcl_Interp *interp, int argc, char **argv));
  913. extern int    Tcl_SeekCmd _ANSI_ARGS_((ClientData clientData,
  914.             Tcl_Interp *interp, int argc, char **argv));
  915. extern int    Tcl_SourceCmd _ANSI_ARGS_((ClientData clientData,
  916.             Tcl_Interp *interp, int argc, char **argv));
  917. extern int    Tcl_TellCmd _ANSI_ARGS_((ClientData clientData,
  918.             Tcl_Interp *interp, int argc, char **argv));
  919. extern int    Tcl_TimeCmd _ANSI_ARGS_((ClientData clientData,
  920.             Tcl_Interp *interp, int argc, char **argv));
  921.  
  922. #ifdef macintosh
  923. #    define ROTATE_THE_CURSOR
  924. #    define ALLOW_USER_BREAK
  925. #endif
  926.  
  927. #endif /* _TCLINT */
  928.